//package convert

package main

/**
|---------------------------------
| 任意类型之间相互转换
| user: fcl date: 2022/7/6
|---------------------------------
| 转载： https://golang-tech-stack.com/post/5108
*/

import (
	"errors"
	"fmt"
	"log"
	"reflect"
	"strconv"
	"time"
)

type RawBytes []byte

var errNilPtr = errors.New("destination pointer i nil")

func convertAssign(dest, src interface{}) error {
	convert := func(d interface{}, hf func()) error {
		if d == nil {
			return errNilPtr
		}
		hf()
		return nil
	}
	switch s := src.(type) {
	case string:
		switch d := dest.(type) {
		case *string:
			return convert(d, func() { *d = s })
		case *[]byte:
			return convert(d, func() { *d = []byte(s) })
		case *RawBytes:
			return convert(d, func() { *d = append((*d)[:0], s...) })
		}
	case []byte:
		switch d := dest.(type) {
		case *string:
			return convert(d, func() { *d = string(s) })
		case *interface{}:
			return convert(d, func() { *d = cloneBytes(s) })
		case *[]byte:
			return convert(d, func() { *d = cloneBytes(s) })
		case *RawBytes:
			return convert(d, func() { *d = s })
		}
	case time.Time:
		switch d := dest.(type) {
		case *time.Time:
			*d = s
			return nil
		case *string:
			*d = s.Format(time.RFC3339Nano)
			return nil
		case *[]byte:
			return convert(d, func() { *d = []byte(s.Format(time.RFC3339Nano)) })
		case *RawBytes:
			return convert(d, func() { *d = s.AppendFormat((*d)[:0], time.RFC3339Nano) })
		}
	case nil:
		switch d := dest.(type) {
		case *interface{}:
			return convert(d, func() { *d = nil })
		case *[]byte:
			return convert(d, func() { *d = nil })
		case *RawBytes:
			return convert(d, func() { *d = nil })
		}
	}
	var sv reflect.Value
	switch d := dest.(type) {
	case *string:
		sv = reflect.ValueOf(src)
		switch sv.Kind() {
		case reflect.Bool, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64,
			reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64,
			reflect.Float32, reflect.Float64:
			*d = asString(src)
			return nil
		}
	case *[]byte:
		sv = reflect.ValueOf(src)
		if b, ok := asBytes(nil, sv); ok {
			*d = b
			return nil
		}
	case *RawBytes:
		sv = reflect.ValueOf(src)
		if b, ok := asBytes([]byte(*d)[:0], sv); ok {
			*d = RawBytes(b)
			return nil
		}
	case *bool:
		bv, err := Bool.ConvertValue(src)
		if err == nil {
			*d = bv.(bool)
		}
		return err
	case *interface{}:
		*d = src
		return nil
	}
	if scanner, ok := dest.(Scanner); ok {
		return scanner.Scan(src)
	}
	dpv := reflect.ValueOf(dest)
	if dpv.Kind() != reflect.Ptr {
		return errors.New("destination not a pointer !")
	}
	if dpv.IsNil() {
		return errNilPtr
	}
	if !sv.IsValid() {
		sv = reflect.ValueOf(src)
	}
	dv := reflect.Indirect(dpv)
	if sv.IsValid() && sv.Type().AssignableTo(dv.Type()) {
		switch b := src.(type) {
		case []byte:
			dv.Set(reflect.ValueOf(cloneBytes(b)))
		default:
			dv.Set(sv)
		}
		return nil
	}
	if dv.Kind() == sv.Kind() && sv.Type().ConvertibleTo(dv.Type()) {
		dv.Set(sv.Convert(dv.Type()))
		return nil
	}
	// The following conversions use a string value as an intermediate representation
	// to convert between various numeric types.
	//
	// This also allows scanning into user defined types such as "type Int int64".
	// For symmetry, also check for string destination types.
	switch dv.Kind() {
	case reflect.Ptr:
		if src == nil {
			dv.Set(reflect.Zero(dv.Type()))
			return nil
		}
		dv.Set(reflect.New(dv.Type().Elem()))
		return convertAssign(dv.Interface(), src)
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		s := asString(src)
		i64, err := strconv.ParseInt(s, 10, dv.Type().Bits())
		if err != nil {
			err = strconvErr(err)
			return fmt.Errorf("converting driver.value type %T (%q) to a %s:%v", src, s, dv.Kind(), err)
		}
		dv.SetInt(i64)
		return nil
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		s := asString(src)
		ui64, err := strconv.ParseUint(s, 10, dv.Type().Bits())
		if err != nil {
			err = strconvErr(err)
			return fmt.Errorf("converting driver.value type %T (%q) to a %s:%v", src, s, dv.Kind(), err)
		}
		dv.SetUint(ui64)
		return nil
	case reflect.Float32, reflect.Float64:
		s := asString(src)
		f64, err := strconv.ParseFloat(s, dv.Type().Bits())
		if err != nil {
			err = strconvErr(err)
			return fmt.Errorf("converting driver.value type %T (%q) to a %s:%v", src, s, dv.Kind(), err)
		}
		dv.SetFloat(f64)
		return nil
	case reflect.String:
		switch v := src.(type) {
		case string:
			dv.SetString(v)
			return nil
		case []byte:
			dv.SetString(string(v))
			return nil
		}
	}
	return fmt.Errorf("unsupport Scan,storing driver.value, type %T into type %T", src, dest)
}

func strconvErr(err error) error {
	if ne, ok := err.(*strconv.NumError); ok {
		return ne.Err
	}
	return err
}

func cloneBytes(b []byte) []byte {
	if b == nil {
		return nil
	}
	c := make([]byte, len(b))
	copy(c, b)
	return c
}

func asString(src interface{}) string {
	switch v := src.(type) {
	case string:
		return v
	case []byte:
		return string(v)
	}
	rv := reflect.ValueOf(src)
	switch rv.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return strconv.FormatInt(rv.Int(), 10)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return strconv.FormatUint(rv.Uint(), 10)
	case reflect.Float32:
		return strconv.FormatFloat(rv.Float(), 'g', -1, 32)
	case reflect.Float64:
		return strconv.FormatFloat(rv.Float(), 'g', -1, 64)
	case reflect.Bool:
		return strconv.FormatBool(rv.Bool())
	}
	return fmt.Sprintf("%v", src)
}

func asBytes(buf []byte, rv reflect.Value) (b []byte, ok bool) {
	switch rv.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		return strconv.AppendInt(buf, rv.Int(), 10), true
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		return strconv.AppendUint(buf, rv.Uint(), 10), true
	case reflect.Float32:
		return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 32), true
	case reflect.Float64:
		return strconv.AppendFloat(buf, rv.Float(), 'g', -1, 64), true
	case reflect.Bool:
		return strconv.AppendBool(buf, rv.Bool()), true
	case reflect.String:
		s := rv.String()
		return append(buf, s...), true

	}
	return
}

type Value interface {
}
type boolType struct {
}

var Bool boolType

func (boolType) String() string {
	return "Bool"
}

func (boolType) ConvertValue(src interface{}) (Value, error) {
	switch s := src.(type) {
	case bool:
		return s, nil
	case string:
		b, err := strconv.ParseBool(s)
		if err != nil {
			return nil, fmt.Errorf("sql/driver:couldn't convert %q into type bool", s)
		}
		return b, nil
	case []byte:
		b, err := strconv.ParseBool(string(s))
		if err != nil {
			return nil, fmt.Errorf("sql/driver:couldn't convert %q into type bool", s)
		}
		return b, nil
	}
	sv := reflect.ValueOf(src)
	switch sv.Kind() {
	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
		iv := sv.Int()
		if iv == 1 || iv == 0 {
			return iv == 1, nil
		}
		return nil, fmt.Errorf("sql/driver:couldn't convert %d into type bool", iv)
	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
		uv := sv.Uint()
		if uv == 1 || uv == 0 {
			return uv == 1, nil
		}
		return nil, fmt.Errorf("sql/driver:couldn't convert %d into type bool", uv)
	}
	return nil, fmt.Errorf("sql/driver:couldn't convert %v (%T) into type bool", src, src)
}

type Scanner interface {
	// Scan assigns a value from a database driver.
	//
	// The src value will be of one of the following types:
	//
	//    int64
	//    float64
	//    bool
	//    []byte
	//    string
	//    time.Time
	//    nil - for NULL values
	//
	// An error should be returned if the value cannot be stored
	// without loss of information.
	//
	// Reference types such as []byte are only valid until the next call to Scan
	// and should not be retained. Their underlying memory is owned by the driver.
	// If retention is necessary, copy their values before the next call to Scan.
	Scan(src interface{}) error
}

func main() {
	var dst1 float64
	var dst2 int
	src := "123"
	if err := convertAssign(&dst1, src); err != nil {
		log.Fatalf("convert faield, %v", err)
	} else {
		log.Printf("convert ok: %f", dst1)
	}

	if err := convertAssign(&dst2, src); err != nil {
		log.Fatalf("convert faield, %v", err)
	} else {
		log.Printf("convert ok: %d", dst2)
	}
	var dst3 bool
	log.Println(convertAssign(&dst3, 1), dst3)
	var dst4 string
	log.Println(convertAssign(&dst4, true), dst4)
	var dst5 time.Time
	//src1 := time.Now().Date()
	log.Println(convertAssign(&dst5, true), dst5)
}
